// internal/parser/parser/expression.go
package parser

import (
	"NumberBase/internal/parser/ast"
	"NumberBase/internal/parser/lexer"
	"fmt"
)

// parseIdentifier 解析标识符表达式
func (p *Parser) parseIdentifier() (ast.Expression, error) {
	ident := &ast.Identifier{Value: p.currToken.Literal}

	// 检查是否是表名限定的列名: table.column
	if p.peekTokenIs(lexer.DOT) {
		p.nextToken() // 跳过点号
		p.nextToken() // 移动到列名

		if !p.currTokenIs(lexer.IDENTIFIER) {
			return nil, fmt.Errorf("期望列名，但得到%s", p.currToken.Literal)
		}

		// 更新标识符的值为 "table.column"
		ident.Value = ident.Value + "." + p.currToken.Literal
	}

	return ident, nil
}

// parseStringLiteral 解析字符串字面量
func (p *Parser) parseStringLiteral() (ast.Expression, error) {
	return &ast.LiteralExpression{
		Value: p.currToken.Literal,
		Type:  ast.STRING,
	}, nil
}

// parseNumberLiteral 解析数字字面量
func (p *Parser) parseNumberLiteral() (ast.Expression, error) {
	return &ast.LiteralExpression{
		Value: p.currToken.Literal,
		Type:  ast.NUMBER,
	}, nil
}

// parseGroupedExpression 解析括号表达式
func (p *Parser) parseGroupedExpression() (ast.Expression, error) {
	p.nextToken() // 跳过左括号

	// 检查是否是子查询
	if p.currTokenIs(lexer.SELECT) {
		subQuery, err := p.parseSelectStatement()
		if err != nil {
			return nil, err
		}

		// 检查右括号
		if !p.currTokenIs(lexer.RPAREN) {
			return nil, fmt.Errorf("期望右括号')'，但得到%s", p.currToken.Literal)
		}

		// 前进到右括号之后的token
		p.nextToken()

		return &ast.SubqueryExpression{Query: subQuery}, nil
	}

	// 不是子查询，而是普通的括号表达式
	exp, err := p.parseExpression(LOWEST)
	if err != nil {
		return nil, err
	}

	if !p.expectPeek(lexer.RPAREN) {
		return nil, fmt.Errorf("期望右括号')'")
	}

	return exp, nil
}

// parseInfixExpression 解析中缀表达式
func (p *Parser) parseInfixExpression(left ast.Expression) (ast.Expression, error) {
	expression := &ast.BinaryExpression{
		Left:     left,
		Operator: convertTokenType(p.currToken.Type),
	}

	precedence := p.currPrecedence()
	p.nextToken()

	right, err := p.parseExpression(precedence)
	if err != nil {
		return nil, err
	}
	expression.Right = right

	return expression, nil
}

// parseExpression 解析表达式
// 使用Pratt解析技术(自顶向下运算符优先级解析)
// 参数:
//   - precedence: 当前上下文的优先级
//
// 返回值:
//   - 解析得到的表达式
//   - 解析错误，如果有
func (p *Parser) parseExpression(precedence int) (ast.Expression, error) {
	// 获取前缀解析函数
	prefix := p.prefixParseFns[p.currToken.Type]
	if prefix == nil {
		return nil, fmt.Errorf("未找到%s的前缀解析函数", p.currToken.Literal)
	}

	// 调用前缀解析函数，得到左侧表达式
	leftExp, err := prefix()
	if err != nil {
		return nil, err
	}

	// 根据优先级处理中缀表达式
	// 只要下一个Token的优先级高于当前上下文优先级，就构建中缀表达式
	for !p.peekTokenIs(lexer.SEMICOLON) && precedence < p.peekPrecedence() {
		infix := p.infixParseFns[p.peekToken.Type]
		if infix == nil {
			return leftExp, nil
		}

		p.nextToken()

		// 调用中缀解析函数，以左侧表达式为参数，构建二元表达式
		leftExp, err = infix(leftExp)
		if err != nil {
			return nil, err
		}
	}

	return leftExp, nil
}

// parseExpressionList 解析由分隔符分隔的表达式列表
// 例如: id, name, age 或 1, 'John', 30
// 参数:
//   - end: 表达式之间的分隔符类型，通常是COMMA
//
// 返回值:
//   - 表达式数组
//   - 解析错误，如果有
func (p *Parser) parseExpressionList(end lexer.TokenType) ([]ast.Expression, error) {
	list := []ast.Expression{}

	// 解析第一个表达式
	expr, err := p.parseExpression(LOWEST)
	if err != nil {
		return nil, err
	}
	list = append(list, expr)

	// 解析后续表达式
	for p.peekTokenIs(end) {
		p.nextToken() // 跳过当前表达式或分隔符
		p.nextToken() // 移动到下一个表达式

		expr, err := p.parseExpression(LOWEST)
		if err != nil {
			return nil, err
		}
		list = append(list, expr)
	}

	return list, nil
}

// convertTokenType 将lexer.TokenType转换为ast.TokenType
func convertTokenType(t lexer.TokenType) ast.TokenType {
	switch t {
	case lexer.EQUAL:
		return ast.EQUAL
	case lexer.NOT_EQUAL:
		return ast.NOT_EQUAL
	case lexer.LESS:
		return ast.LESS
	case lexer.LESS_EQUAL:
		return ast.LESS_EQUAL
	case lexer.GREATER:
		return ast.GREATER
	case lexer.GREATER_EQUAL:
		return ast.GREATER_EQUAL
	case lexer.AND:
		return ast.AND
	case lexer.OR:
		return ast.OR
	default:
		return 0 // 未知类型
	}
}

// parseIdentifierList 解析标识符列表
// 解析格式如: (id, name, age)
// 返回值:
//   - 标识符字符串数组
//   - 解析错误，如果有
func (p *Parser) parseIdentifierList() ([]string, error) {
	identifiers := []string{}

	// 跳过左括号
	p.nextToken()

	// 第一个标识符
	if !p.currTokenIs(lexer.IDENTIFIER) {
		return nil, fmt.Errorf("期望标识符，但得到%s", p.currToken.Literal)
	}

	identifiers = append(identifiers, p.currToken.Literal)

	// 解析剩余标识符
	for p.peekTokenIs(lexer.COMMA) {
		p.nextToken() // 跳过当前标识符或逗号
		p.nextToken() // 移动到下一个标识符

		if !p.currTokenIs(lexer.IDENTIFIER) {
			return nil, fmt.Errorf("期望标识符，但得到%s", p.currToken.Literal)
		}

		identifiers = append(identifiers, p.currToken.Literal)
	}

	// 期望下一个Token是右括号
	if !p.expectPeek(lexer.RPAREN) {
		return nil, fmt.Errorf("期望)，但得到%s", p.peekToken.Literal)
	}

	return identifiers, nil
}

// parseAsterisk 解析SELECT语句中的星号(*)，表示选择所有列
func (p *Parser) parseAsterisk() (ast.Expression, error) {
	return &ast.AsteriskExpression{}, nil
}
